# load pretty jupyter's magics
%load_ext pretty_jupyter

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split,cross_val_score,cross_val_predict
from sklearn.metrics import roc_curve,roc_auc_score
from sklearn.svm import SVC

pd.set_option('display.max_colwidth', None) 

suicide = pd.read_csv('./Suicide_Detection.csv',usecols=['text','class'])

suicide.head()

suicide[['class']].value_counts()

sample_suicide = suicide.iloc[:5000]#We will limit the dataset to first 5,000 for faster computing

sample_suicide.shape

sample_suicide[['class']].value_counts()#Label variable seems to be balanced

sample_suicide['class'] = np.where(sample_suicide['class']=='suicide',1,0)#Converting label to numeric where suicide=1 non-suicide=0

sample_suicide.isna().sum()#check for missing; No missing

sample_suicide['text'].duplicated().sum()#Check for duplicated text; No duplicated test

len(sample_suicide[sample_suicide['text']==''])#No empty text

# Labels
y = sample_suicide['class']
# Features
X = sample_suicide.drop('class',axis=1)

X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=.2,random_state=42)

from sklearn.pipeline import Pipeline
from sklearn.naive_bayes import MultinomialNB, ComplementNB,GaussianNB 
from sklearn.ensemble import RandomForestClassifier 
from sklearn.neighbors import KNeighborsClassifier 
from sklearn.svm import LinearSVC
from sklearn.metrics import accuracy_score,classification_report

vectorizer = TfidfVectorizer()
X_train_vectorized = vectorizer.fit_transform(X_train['text'])

gnb_clf = GaussianNB()
print(cross_val_score(gnb_clf,X_train_vectorized.toarray(),y_train,cv=3))
y_probas_gnb = cross_val_predict(gnb_clf,X_train_vectorized.toarray(),y_train,cv=3,method='predict_proba')
y_scores_gnb = y_probas_gnb[:,1]

cnb_clf = ComplementNB()
cnb_clf.fit(X_train_vectorized,y_train)
print(cross_val_score(cnb_clf,X_train_vectorized,y_train,cv=3))
y_probas_cnb  = cross_val_predict(cnb_clf,X_train_vectorized,y_train,cv=3,method='predict_proba')
y_scores_cnb = y_probas_cnb[:,1]

mnb_clf = MultinomialNB()
mnb_clf.fit(X_train_vectorized,y_train)
print(cross_val_score(mnb_clf,X_train_vectorized,y_train,cv=3))
y_probas_mnb = cross_val_predict(mnb_clf,X_train_vectorized,y_train,cv=3,method='predict_proba')
y_scores_mnb = y_probas_mnb[:,1]

rf_clf = RandomForestClassifier(random_state=42)
print(cross_val_score(rf_clf,X_train_vectorized,y_train,cv=3))
y_probas_rf = cross_val_predict(rf_clf,X_train_vectorized,y_train,cv=3,method="predict_proba")
y_scores_rf = y_probas_rf[:,1]

knn_clf = KNeighborsClassifier()
print(cross_val_score(knn_clf,X_train_vectorized,y_train,cv=3))
y_probas_knn = cross_val_predict(knn_clf,X_train_vectorized,y_train,cv=3,method='predict_proba')
y_scores_knn = y_probas_knn[:,1]

svc_clf = LinearSVC()
print(cross_val_score(svc_clf,X_train_vectorized,y_train,cv=3))
y_scores_svc = cross_val_predict(svc_clf,X_train_vectorized,y_train,cv=3,method='decision_function')

model_pred_dict = {
    'GNB':y_scores_gnb,
    'CNB':y_scores_cnb,
    'MNB':y_scores_mnb,
    'RF':y_scores_rf,
    'KNN':y_scores_knn,
    'SVC':y_scores_svc
}

fpr_gnb,tpr_gnb,thresholds_gnb = roc_curve(y_train,y_scores_gnb)
fpr_cnb,tpr_cnb,thresholds_cnb = roc_curve(y_train,y_scores_cnb)
fpr_mnb,tpr_mnb,thresholds_mnb = roc_curve(y_train,y_scores_mnb)
fpr_rf,tpr_rf,thresholds_rf    = roc_curve(y_train,y_scores_rf)
fpr_knn,tpr_knn,thresholds_knn = roc_curve(y_train,y_scores_knn)
fpr_svc,tpr_svc,thresholds_svc = roc_curve(y_train,y_scores_svc)

def plot_roc_curve():
    #plt.plot(fpr,tpr,linewidth=2,label=label)
    plt.plot([0,1],[0,1],'k--')
    plt.xlim([0.0, 1.0])
    plt.ylim([0.0, 1.0])
    plt.xlabel('False Positive Rate')
    plt.ylabel('True Positive Rate (Recall)')
    plt.title('ROC Curve for Suicide Classification')

model_color_dict = {
    'GNB':'red',
    'CNB':'blue',
    'MNB':'green',
    'RF':'yellow',
    'KNN':'brown',
    'SVC':'purple'
}

plot_roc_curve()
for model_name, y_pred in model_pred_dict.items():
    fpr_gnb,tpr_gnb,thresholds_gnb = roc_curve(y_train,y_pred)
    plt.plot(fpr_gnb,tpr_gnb,color = model_color_dict[model_name],label=model_name)
plt.legend(loc='lower right')
plt.show()

print('ROC AUC scores:')
for model_name, y_pred in model_pred_dict.items():
    print(f'{model_name}: {roc_auc_score(y_train,y_pred):.3f}')

model_dict = {
    'GNB':gnb_clf,
    'CNB':cnb_clf,
    'MNB':mnb_clf,
    'RF':rf_clf,
    'KNN':knn_clf,
    'SVC':svc_clf
}

for model_name,model in model_dict.items():
    print(model_name)
    if model_name=='GNB':
        y_pred = cross_val_predict(model,X_train_vectorized.toarray(),y_train,cv=3)
    else:
        y_pred = cross_val_predict(model,X_train_vectorized,y_train,cv=3)
    print(classification_report(y_train,y_pred))

y_train_pred = cross_val_predict(svc_clf,X_train_vectorized,y_train,cv=3)

X_tp = X_train[(y_train == 1) & (y_train_pred == 1)]
X_fn = X_train[(y_train == 1) & (y_train_pred == 0)]
X_fp = X_train[(y_train == 0) & (y_train_pred == 1)]
X_tn = X_train[(y_train == 0) & (y_train_pred == 0)]

X_fp.head()

X_fp['text'].str.len().describe()

X_fn.head()

X_fn['text'].str.len().describe()

X_tn.head()

X_tn['text'].str.len().describe()

X_tp.head()

X_tp['text'].str.len().describe()

vectorizer = TfidfVectorizer(ngram_range = (1,3),stop_words='english')
X_train_vectorized_n13_en = vectorizer.fit_transform(X_train['text'])
y_pred_n13_en = cross_val_predict(svc_clf,X_train_vectorized_n13_en,y_train,cv=3)
print(classification_report(y_train,y_pred_n13_en))

vectorizer = TfidfVectorizer(ngram_range = (1,3))
X_train_vectorized_n13 = vectorizer.fit_transform(X_train['text'])
y_pred_n13 = cross_val_predict(svc_clf,X_train_vectorized_n13,y_train,cv=3)
print(classification_report(y_train,y_pred_n13))

vectorizer = TfidfVectorizer(stop_words='english')
X_train_vectorized_en = vectorizer.fit_transform(X_train['text'])
y_pred_en = cross_val_predict(svc_clf,X_train_vectorized_en,y_train,cv=3)
print(classification_report(y_train,y_pred_en))

vectorizer = TfidfVectorizer(stop_words='english',ngram_range = (1,2))
X_train_vectorized_en = vectorizer.fit_transform(X_train['text'])
y_pred_en = cross_val_predict(svc_clf,X_train_vectorized_en,y_train,cv=3)
print(classification_report(y_train,y_pred_en))

vectorizer = TfidfVectorizer(ngram_range = (1,2))
X_train_vectorized_en = vectorizer.fit_transform(X_train['text'])
y_pred_en = cross_val_predict(svc_clf,X_train_vectorized_en,y_train,cv=3)
print(classification_report(y_train,y_pred_en))

predictSVC = svc_clf.predict(X_test_vectorized)
print(f'SVC accuracy score: {accuracy_score(y_test,predictSVC):.2f}')
print(f'SVC ROC AUC score: {roc_auc_score(y_test,predictSVC):.2f}')

msg = 'some example post'
pipeSVC.predict([msg])